রেগুলার এক্সপ্রেশন অপ্টিমাইজেশন: Regex পারফরম্যান্স টিউনিং এর এক গভীর বিশ্লেষণ

রেগুলার এক্সপ্রেশন বা রেজেক্স, আধুনিক প্রোগ্রামারদের টুলকিটে একটি অপরিহার্য টুল। ব্যবহারকারীর ইনপুট যাচাই করা এবং লগ ফাইল পার্স করা থেকে শুরু করে অত্যাধুনিক সার্চ-এন্ড-রিপ্লেস অপারেশন এবং ডেটা এক্সট্র্যাকশন পর্যন্ত, এর ক্ষমতা এবং বহুমুখিতা অনস্বীকার্য। তবে, এই ক্ষমতার সাথে একটি লুকানো খরচও আসে। একটি খারাপভাবে লেখা রেজেক্স একটি নীরব পারফরম্যান্স কিলার হয়ে উঠতে পারে, যা উল্লেখযোগ্য ল্যাটেন্সি তৈরি করে, সিপিইউ স্পাইক ঘটায় এবং সবচেয়ে খারাপ ক্ষেত্রে, আপনার অ্যাপ্লিকেশনকে থামিয়ে দিতে পারে। এখানেই রেগুলার এক্সপ্রেশন অপ্টিমাইজেশন শুধুমাত্র একটি 'থাকলে ভালো' দক্ষতা নয়, বরং শক্তিশালী এবং পরিমাপযোগ্য সফ্টওয়্যার তৈরির জন্য একটি গুরুত্বপূর্ণ দক্ষতা হয়ে ওঠে।

এই বিস্তারিত গাইডটি আপনাকে রেজেক্স পারফরম্যান্সের জগতে গভীরভাবে নিয়ে যাবে। আমরা অন্বেষণ করব কেন একটি আপাতদৃষ্টিতে সহজ প্যাটার্ন বিপর্যয়করভাবে ধীর হতে পারে, রেজেক্স ইঞ্জিনের অভ্যন্তরীণ কার্যকারিতা বুঝব এবং আপনাকে এমন একটি শক্তিশালী নীতি ও কৌশলের সেট দিয়ে সজ্জিত করব যা দিয়ে কেবল সঠিকই নয়, বরং অত্যন্ত দ্রুত রেগুলার এক্সপ্রেশনও লিখতে পারবেন।

'কেন' বোঝা: একটি খারাপ Regex-এর খেসারত

অপ্টিমাইজেশন কৌশলগুলিতে যাওয়ার আগে, আমরা যে সমস্যাটি সমাধান করার চেষ্টা করছি তা বোঝা অত্যন্ত গুরুত্বপূর্ণ। রেগুলার এক্সপ্রেশনের সাথে যুক্ত সবচেয়ে গুরুতর পারফরম্যান্স সমস্যাটি ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিং (Catastrophic Backtracking) নামে পরিচিত, যা একটি রেগুলার এক্সপ্রেশন ডিনায়েল অফ সার্ভিস (ReDoS) দুর্বলতার কারণ হতে পারে।

ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিং (Catastrophic Backtracking) কী?

ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিং ঘটে যখন একটি রেজেক্স ইঞ্জিন একটি ম্যাচ খুঁজে পেতে (বা কোনো ম্যাচ সম্ভব নয় তা নির্ধারণ করতে) অস্বাভাবিকভাবে দীর্ঘ সময় নেয়। এটি নির্দিষ্ট ধরনের প্যাটার্নের বিরুদ্ধে নির্দিষ্ট ধরনের ইনপুট স্ট্রিংয়ের ক্ষেত্রে ঘটে। ইঞ্জিনটি পারমুটেশনের এক মাথা ঘুরিয়ে দেওয়া গোলকধাঁধায় আটকে যায়, প্যাটার্নটি মেলানোর জন্য প্রতিটি সম্ভাব্য পথ চেষ্টা করে। ইনপুট স্ট্রিংয়ের দৈর্ঘ্যের সাথে ধাপের সংখ্যা দ্রুতগতিতে বাড়তে পারে, যা দেখে মনে হয় অ্যাপ্লিকেশনটি জমে গেছে।

এই দুর্বল রেজেক্সটির ক্লাসিক উদাহরণটি বিবেচনা করুন: ^(a+)+$

এই প্যাটার্নটি যথেষ্ট সহজ মনে হতে পারে: এটি এক বা একাধিক 'a' দিয়ে গঠিত একটি স্ট্রিং খোঁজে। এটি "a", "aa", এবং "aaaaa" এর মতো স্ট্রিংয়ের জন্য পুরোপুরি কাজ করে। সমস্যাটি দেখা দেয় যখন আমরা এটিকে এমন একটি স্ট্রিংয়ের বিরুদ্ধে পরীক্ষা করি যা প্রায় মিলে যায় কিন্তু শেষ পর্যন্ত ব্যর্থ হয়, যেমন "aaaaaaaaaaaaaaaaaaaaaaaaaaab"।

এখানে এটি এত ধীর কেন তার কারণ দেওয়া হলো:

• বাইরের (...)+ এবং ভেতরের a+ উভয়ই গ্রিডি কোয়ান্টিফায়ার।
• ভেতরের a+ প্রথমে সমস্ত 27টি 'a' ম্যাচ করে।
• বাইরের (...)+ এই একটি ম্যাচেই সন্তুষ্ট হয়।
• তারপর ইঞ্জিন স্ট্রিংয়ের শেষ অ্যাঙ্কর $ ম্যাচ করার চেষ্টা করে। এটি ব্যর্থ হয় কারণ সেখানে একটি 'b' আছে।
• এখন, ইঞ্জিনকে অবশ্যই ব্যাকট্র্যাক করতে হবে। বাইরের গ্রুপটি একটি অক্ষর ছেড়ে দেয়, তাই ভেতরের a+ এখন 26টি 'a' ম্যাচ করে, এবং বাইরের গ্রুপের দ্বিতীয় পুনরাবৃত্তিটি শেষ 'a' ম্যাচ করার চেষ্টা করে। এটিও 'b'-এর কাছে ব্যর্থ হয়।
• ইঞ্জিনটি এখন ভেতরের a+ এবং বাইরের (...)+ এর মধ্যে 'a' এর স্ট্রিংকে ভাগ করার প্রতিটি সম্ভাব্য উপায় চেষ্টা করবে। N সংখ্যক 'a' এর একটি স্ট্রিংয়ের জন্য, এটিকে ভাগ করার 2^N-1 টি উপায় রয়েছে। এর জটিলতা সূচকীয়, এবং প্রক্রিয়াকরণের সময় আকাশচুম্বী হয়ে যায়।

এই একটি, আপাতদৃষ্টিতে নিরীহ রেজেক্স একটি সিপিইউ কোরকে সেকেন্ড, মিনিট বা তারও বেশি সময়ের জন্য লক করে দিতে পারে, যা কার্যকরভাবে অন্যান্য প্রসেস বা ব্যবহারকারীদের জন্য পরিষেবা বন্ধ করে দেয়।

মূল বিষয়: রেজেক্স ইঞ্জিন

রেজেক্স অপ্টিমাইজ করার জন্য, আপনাকে বুঝতে হবে ইঞ্জিন আপনার প্যাটার্নটি কীভাবে প্রক্রিয়া করে। প্রধানত দুই ধরনের রেজেক্স ইঞ্জিন রয়েছে, এবং তাদের অভ্যন্তরীণ কার্যকারিতা পারফরম্যান্সের বৈশিষ্ট্য নির্ধারণ করে।

DFA (Deterministic Finite Automaton) ইঞ্জিন

DFA ইঞ্জিনগুলি রেজেক্স জগতের গতির দানব। তারা ইনপুট স্ট্রিংকে বাম থেকে ডানে, অক্ষর ধরে ধরে একবারে প্রক্রিয়া করে। যেকোনো মুহূর্তে, একটি DFA ইঞ্জিন বর্তমান অক্ষরের উপর ভিত্তি করে পরবর্তী অবস্থা কী হবে তা ঠিক জানে। এর মানে হলো এটিকে কখনও ব্যাকট্র্যাক করতে হয় না। প্রক্রিয়াকরণের সময় রৈখিক এবং সরাসরি ইনপুট স্ট্রিংয়ের দৈর্ঘ্যের সমানুপাতিক। যে টুলগুলি DFA-ভিত্তিক ইঞ্জিন ব্যবহার করে তার উদাহরণগুলির মধ্যে রয়েছে প্রথাগত ইউনিক্স টুল যেমন grep এবং awk।

সুবিধা: অত্যন্ত দ্রুত এবং অনুমানযোগ্য পারফরম্যান্স। ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিং থেকে মুক্ত।

অসুবিধা: সীমিত বৈশিষ্ট্য সেট। তারা ব্যাকরেফারেন্স, লুকঅ্যারাউন্ড, বা ক্যাপচারিং গ্রুপের মতো উন্নত বৈশিষ্ট্য সমর্থন করে না, যা ব্যাকট্র্যাক করার ক্ষমতার উপর নির্ভর করে।

NFA (Nondeterministic Finite Automaton) ইঞ্জিন

NFA ইঞ্জিনগুলি আধুনিক প্রোগ্রামিং ভাষা যেমন পাইথন, জাভাস্ক্রিপ্ট, জাভা, C# (.NET), রুবি, পিএইচপি এবং পার্ল-এ ব্যবহৃত সবচেয়ে সাধারণ প্রকার। এগুলি "প্যাটার্ন-চালিত," যার মানে ইঞ্জিনটি প্যাটার্ন অনুসরণ করে, স্ট্রিংয়ের মধ্য দিয়ে এগিয়ে যায়। যখন এটি একটি অস্পষ্টতার পর্যায়ে পৌঁছায় (যেমন একটি অল্টারনেশন | বা একটি কোয়ান্টিফায়ার *, +), এটি একটি পথ চেষ্টা করবে। যদি সেই পথটি শেষ পর্যন্ত ব্যর্থ হয়, তবে এটি শেষ সিদ্ধান্ত নেওয়ার বিন্দুতে ব্যাকট্র্যাক করে এবং পরবর্তী উপলব্ধ পথটি চেষ্টা করে।

এই ব্যাকট্র্যাকিং ক্ষমতাটিই NFA ইঞ্জিনগুলিকে এত শক্তিশালী এবং বৈশিষ্ট্য সমৃদ্ধ করে তোলে, যা লুকঅ্যারাউন্ড এবং ব্যাকরেফারেন্স সহ জটিল প্যাটার্নগুলিকে সক্ষম করে। যাইহোক, এটি তাদের অ্যাকিলিসের হিলও বটে, কারণ এটিই সেই প্রক্রিয়া যা ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিংকে সক্ষম করে।

এই গাইডের বাকি অংশের জন্য, আমাদের অপ্টিমাইজেশন কৌশলগুলি NFA ইঞ্জিনকে নিয়ন্ত্রণে আনার উপর মনোযোগ দেবে, কারণ এখানেই ডেভেলপাররা প্রায়শই পারফরম্যান্স সমস্যার সম্মুখীন হন।

NFA ইঞ্জিনের জন্য মূল অপ্টিমাইজেশন নীতি

এখন, আসুন আমরা উচ্চ-পারফরম্যান্স রেগুলার এক্সপ্রেশন লেখার জন্য ব্যবহারযোগ্য ব্যবহারিক, কার্যকর কৌশলগুলির মধ্যে ডুব দিই।

১. সুনির্দিষ্ট হন: নির্ভুলতার শক্তি

সবচেয়ে সাধারণ পারফরম্যান্স অ্যান্টি-প্যাটার্ন হলো .* এর মতো অতিরিক্ত জেনেরিক ওয়াইল্ডকার্ড ব্যবহার করা। ডট . (প্রায়) যেকোনো অক্ষর ম্যাচ করে, এবং অ্যাস্টেরিস্ক * এর অর্থ "শূন্য বা তার বেশি বার।" যখন এগুলি একত্রিত হয়, তখন তারা ইঞ্জিনকে লোভের সাথে বাকি পুরো স্ট্রিংটি গ্রাস করতে এবং তারপর প্যাটার্নের বাকি অংশ ম্যাচ করতে পারে কিনা তা দেখার জন্য এক এক করে অক্ষর ব্যাকট্র্যাক করতে নির্দেশ দেয়। এটি অবিশ্বাস্যভাবে অদক্ষ।

খারাপ উদাহরণ (একটি HTML শিরোনাম পার্স করা):

<title>.*</title>

একটি বড় HTML ডকুমেন্টের বিরুদ্ধে, .* প্রথমে ফাইলের শেষ পর্যন্ত সবকিছু ম্যাচ করবে। তারপর, এটি অক্ষর ধরে ধরে ব্যাকট্র্যাক করবে, যতক্ষণ না এটি চূড়ান্ত </title> খুঁজে পায়। এটি অনেক অপ্রয়োজনীয় কাজ।

ভালো উদাহরণ (একটি নেগেটেড ক্যারেক্টার ক্লাস ব্যবহার করে):

<title>[^<]*</title>

এই সংস্করণটি অনেক বেশি কার্যকর। নেগেটেড ক্যারেক্টার ক্লাস [^<]* এর অর্থ হলো "এমন যেকোনো অক্ষর ম্যাচ করো যা '<' নয়, শূন্য বা তার বেশি বার।" ইঞ্জিনটি এগিয়ে যায়, অক্ষর গ্রহণ করতে থাকে যতক্ষণ না এটি প্রথম '<' তে পৌঁছায়। এটিকে কখনও ব্যাকট্র্যাক করতে হয় না। এটি একটি সরাসরি, দ্ব্যর্থহীন নির্দেশ যা একটি বিশাল পারফরম্যান্সের উন্নতি ঘটায়।

২. গ্রিডি বনাম লেজি ম্যাচিং আয়ত্ত করুন: প্রশ্নবোধক চিহ্নের শক্তি

রেজেক্সে কোয়ান্টিফায়ারগুলি ডিফল্টরূপে গ্রিডি (greedy) হয়। এর মানে হলো তারা যতটা সম্ভব টেক্সট ম্যাচ করে, যতক্ষণ সামগ্রিক প্যাটার্নটি ম্যাচ করতে পারে।

• গ্রিডি: *, +, ?, {n,m}

আপনি যেকোনো কোয়ান্টিফায়ারের পরে একটি প্রশ্নবোধক চিহ্ন যোগ করে সেটিকে লেজি (lazy) করতে পারেন। একটি লেজি কোয়ান্টিফায়ার যতটা সম্ভব কম টেক্সট ম্যাচ করে।

• লেজি: *?, +?, ??, {n,m}?

উদাহরণ: বোল্ড ট্যাগ ম্যাচ করা

ইনপুট স্ট্রিং: <b>First</b> and <b>Second</b>

• গ্রিডি প্যাটার্ন: <b>.*</b>
  এটি ম্যাচ করবে: <b>First</b> and <b>Second</b>। .* লোভের সাথে শেষ </b> পর্যন্ত সবকিছু গ্রাস করেছে।
• লেজি প্যাটার্ন: <b>.*?</b>
  এটি প্রথম চেষ্টায় <b>First</b> ম্যাচ করবে এবং আপনি যদি আবার সার্চ করেন তবে <b>Second</b> ম্যাচ করবে। .*? প্যাটার্নের বাকি অংশ (</b>) ম্যাচ করার জন্য প্রয়োজনীয় সর্বনিম্ন সংখ্যক অক্ষর ম্যাচ করেছে।

যদিও লেজি কোয়ান্টিফায়ার নির্দিষ্ট ম্যাচিং সমস্যা সমাধান করতে পারে, এটি পারফরম্যান্সের জন্য কোনো জাদুকরী সমাধান নয়। একটি লেজি ম্যাচের প্রতিটি ধাপে ইঞ্জিনকে প্যাটার্নের পরবর্তী অংশ ম্যাচ করছে কিনা তা পরীক্ষা করতে হয়। একটি অত্যন্ত সুনির্দিষ্ট প্যাটার্ন (আগের পয়েন্টের নেগেটেড ক্যারেক্টার ক্লাসের মতো) প্রায়শই একটি লেজি প্যাটার্নের চেয়ে দ্রুত হয়।

পারফরম্যান্সের ক্রম (দ্রুততম থেকে ধীরতম):

1. সুনির্দিষ্ট/নেগেটেড ক্যারেক্টার ক্লাস: <b>[^<]*</b>
2. লেজি কোয়ান্টিফায়ার: <b>.*?</b>
3. প্রচুর ব্যাকট্র্যাকিং সহ গ্রিডি কোয়ান্টিফায়ার: <b>.*</b>

৩. ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিং এড়িয়ে চলুন: নেস্টেড কোয়ান্টিফায়ার নিয়ন্ত্রণ করুন

আমরা প্রাথমিক উদাহরণে যেমন দেখেছি, ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিংয়ের সরাসরি কারণ হলো এমন একটি প্যাটার্ন যেখানে একটি কোয়ান্টিফাইড গ্রুপের মধ্যে আরেকটি কোয়ান্টিফায়ার থাকে যা একই টেক্সট ম্যাচ করতে পারে। ইঞ্জিনটি একটি দ্ব্যর্থক পরিস্থিতির মুখোমুখি হয় যেখানে ইনপুট স্ট্রিংকে ভাগ করার একাধিক উপায় থাকে।

সমস্যাযুক্ত প্যাটার্ন:

• (a+)+
• (a*)*
• (a|aa)+
• (a|b)* যেখানে ইনপুট স্ট্রিংয়ে অনেক 'a' এবং 'b' থাকে।

এর সমাধান হলো প্যাটার্নটিকে দ্ব্যর্থহীন করা। আপনাকে নিশ্চিত করতে হবে যে ইঞ্জিনটির একটি প্রদত্ত স্ট্রিং ম্যাচ করার জন্য কেবল একটিই উপায় আছে।

৪. অ্যাটোমিক গ্রুপ এবং পসেসিভ কোয়ান্টিফায়ার ব্যবহার করুন

এটি আপনার এক্সপ্রেশন থেকে ব্যাকট্র্যাকিং বাদ দেওয়ার জন্য সবচেয়ে শক্তিশালী কৌশলগুলির মধ্যে একটি। অ্যাটোমিক গ্রুপ এবং পসেসিভ কোয়ান্টিফায়ার ইঞ্জিনকে বলে: "একবার আপনি প্যাটার্নের এই অংশটি ম্যাচ করে ফেললে, কখনও কোনো অক্ষর ফিরিয়ে দেবেন না। এই এক্সপ্রেশনে ব্যাকট্র্যাক করবেন না।"

পসেসিভ কোয়ান্টিফায়ার (Possessive Quantifiers)

একটি সাধারণ কোয়ান্টিফায়ারের পরে একটি + যোগ করে একটি পসেসিভ কোয়ান্টিফায়ার তৈরি করা হয় (যেমন, *+, ++, ?+, {n,m}+)। এগুলি জাভা, PCRE (পিএইচপি, আর), এবং রুবির মতো ইঞ্জিন দ্বারা সমর্থিত।

উদাহরণ: একটি সংখ্যার পরে 'a' ম্যাচ করা

ইনপুট স্ট্রিং: 12345

• সাধারণ রেজেক্স: \d+a
\d+ "12345" ম্যাচ করে। তারপর, ইঞ্জিন 'a' ম্যাচ করার চেষ্টা করে এবং ব্যর্থ হয়। এটি ব্যাকট্র্যাক করে, তাই \d+ এখন "1234" ম্যাচ করে এবং এটি '5' এর বিরুদ্ধে 'a' ম্যাচ করার চেষ্টা করে। এটি ততক্ষণ চলতে থাকে যতক্ষণ না \d+ তার সমস্ত অক্ষর ছেড়ে দেয়। ব্যর্থ হওয়ার জন্য এটি অনেক কাজ।
• পসেসিভ রেজেক্স: \d++a
\d++ পসেসিভভাবে "12345" ম্যাচ করে। ইঞ্জিন তারপর 'a' ম্যাচ করার চেষ্টা করে এবং ব্যর্থ হয়। যেহেতু কোয়ান্টিফায়ারটি পসেসিভ ছিল, তাই ইঞ্জিনকে \d++ অংশে ব্যাকট্র্যাক করতে নিষেধ করা হয়েছে। এটি অবিলম্বে ব্যর্থ হয়। একে 'দ্রুত ব্যর্থ হওয়া' (failing fast) বলা হয় এবং এটি অত্যন্ত কার্যকর।

অ্যাটোমিক গ্রুপ (Atomic Groups)

অ্যাটোমিক গ্রুপের সিনট্যাক্স হলো (?>...) এবং এটি পসেসিভ কোয়ান্টিফায়ারের চেয়ে বেশি সমর্থিত (যেমন, .NET, পাইথনের নতুন `regex` মডিউলে)। তারা পসেসিভ কোয়ান্টিফায়ারের মতোই আচরণ করে তবে একটি সম্পূর্ণ গ্রুপের উপর প্রযোজ্য হয়।

রেজেক্স (?>\d+)a কার্যকরীভাবে \d++a এর সমতুল্য। আপনি মূল ক্যাটাস্ট্রফিক ব্যাকট্র্যাকিং সমস্যা সমাধানের জন্য অ্যাটোমিক গ্রুপ ব্যবহার করতে পারেন:

মূল সমস্যা: (a+)+
অ্যাটোমিক সমাধান: ((?>a+))+

এখন, যখন ভেতরের গ্রুপ (?>a+) 'a' এর একটি ক্রম ম্যাচ করে, তখন এটি বাইরের গ্রুপের পুনরায় চেষ্টা করার জন্য সেগুলি ছেড়ে দেবে না। এটি দ্ব্যর্থতা দূর করে এবং সূচকীয় ব্যাকট্র্যাকিং প্রতিরোধ করে।

৫. অল্টারনেশন (Alternation) এর ক্রম গুরুত্বপূর্ণ

যখন একটি NFA ইঞ্জিন একটি অল্টারনেশন (| পাইপ ব্যবহার করে) এর সম্মুখীন হয়, তখন এটি বাম থেকে ডানে বিকল্পগুলি চেষ্টা করে। এর মানে হলো আপনার সবচেয়ে সম্ভাব্য বিকল্পটি প্রথমে রাখা উচিত।

উদাহরণ: একটি কমান্ড পার্স করা

কল্পনা করুন আপনি কমান্ড পার্স করছেন, এবং আপনি জানেন যে `GET` কমান্ডটি ৮০% সময়, `SET` ১৫% সময়, এবং `DELETE` ৫% সময় আসে।

কম কার্যকর: ^(DELETE|SET|GET)
আপনার ৮০% ইনপুটের ক্ষেত্রে, ইঞ্জিন প্রথমে `DELETE` ম্যাচ করার চেষ্টা করবে, ব্যর্থ হবে, ব্যাকট্র্যাক করবে, `SET` ম্যাচ করার চেষ্টা করবে, ব্যর্থ হবে, ব্যাকট্র্যাক করবে এবং অবশেষে `GET` দিয়ে সফল হবে।

বেশি কার্যকর: ^(GET|SET|DELETE)
এখন, ৮০% সময়, ইঞ্জিন প্রথম চেষ্টাতেই একটি ম্যাচ পেয়ে যায়। লক্ষ লক্ষ লাইন প্রক্রিয়া করার সময় এই ছোট পরিবর্তনটি একটি লক্ষণীয় প্রভাব ফেলতে পারে।

৬. যখন ক্যাপচারের প্রয়োজন নেই তখন নন-ক্যাপচারিং গ্রুপ ব্যবহার করুন

রেজেক্সে প্যারেন্থেসিস (...) দুটি কাজ করে: তারা একটি সাব-প্যাটার্নকে গ্রুপ করে, এবং তারা সেই সাব-প্যাটার্নের সাথে ম্যাচ করা টেক্সট ক্যাপচার করে। এই ক্যাপচার করা টেক্সটটি পরে ব্যবহারের জন্য মেমরিতে সংরক্ষণ করা হয় (যেমন, `\1` এর মতো ব্যাকরেফারেন্সে বা কলিং কোড দ্বারা নিষ্কাশনের জন্য)। এই সংরক্ষণের একটি ছোট কিন্তু পরিমাপযোগ্য ওভারহেড আছে।

যদি আপনার কেবল গ্রুপিং আচরণের প্রয়োজন হয় কিন্তু টেক্সট ক্যাপচার করার প্রয়োজন না হয়, তাহলে একটি নন-ক্যাপচারিং গ্রুপ ব্যবহার করুন: (?:...)।

ক্যাপচারিং: (https?|ftp)://([^/]+)
এটি "http" এবং ডোমেন নামকে আলাদাভাবে ক্যাপচার করে।

নন-ক্যাপচারিং: (?:https?|ftp)://([^/]+)
এখানে, আমরা এখনও https?|ftp গ্রুপ করি যাতে :// সঠিকভাবে প্রয়োগ হয়, কিন্তু আমরা ম্যাচ করা প্রোটোকল সংরক্ষণ করি না। এটি সামান্য বেশি কার্যকর যদি আপনি কেবল ডোমেন নাম (যা গ্রুপ ১-এ আছে) নিষ্কাশন করতে আগ্রহী হন।

উন্নত কৌশল এবং ইঞ্জিন-নির্দিষ্ট টিপস

লুকঅ্যারাউন্ড (Lookarounds): শক্তিশালী কিন্তু সতর্কতার সাথে ব্যবহার করুন

লুকঅ্যারাউন্ড (লুকএহেড (?=...), (?!...) এবং লুকবিহাইন্ড (?<=...), (?) হলো শূন্য-প্রস্থের অ্যাসারশন। তারা কোনো অক্ষর গ্রহণ না করেই একটি শর্ত পরীক্ষা করে। এটি কনটেক্সট যাচাই করার জন্য খুব কার্যকর হতে পারে।

import re

# রেজেক্সটি একবার কম্পাইল করুন
log_pattern = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')

for line in log_file:
    # কম্পাইল করা অবজেক্টটি ব্যবহার করুন
    match = log_pattern.search(line)
    if match:
        print(match.group(1))